const dayjs = require('dayjs');
/**
 * 日期时间工具类
 * PLM项目专用
 * v1.1 - 优化Day.js实现，增强错误处理
 */

// 尝试加载全局时间辅助类
let globalTimeHelper = null;
let globalTimeHelperPath = null;

// 使用嵌套的try-catch尝试不同路径
try {
  globalTimeHelper = require('../config/path_resolver').pageHelper;
  globalTimeHelperPath = '../../../helpers/time_helper.js';
  console.log('成功加载全局time_helper: ../../../helpers/time_helper.js');
} catch (e) {
  console.warn('尝试路径失败: ../../../helpers/time_helper.js');
  try {
    globalTimeHelper = require('../config/path_resolver').pageHelper;
    globalTimeHelperPath = '../../../../helpers/time_helper.js';
    console.log('成功加载全局time_helper: ../../../../helpers/time_helper.js');
  } catch (e) {
    console.warn('尝试路径失败: ../../../../helpers/time_helper.js');
    try {
      globalTimeHelper = require('../../../comm/helper/time_helper.js');
      globalTimeHelperPath = '../../../comm/helper/time_helper.js';
      console.log('成功加载全局time_helper: ../../../comm/helper/time_helper.js');
    } catch (e) {
      console.warn('尝试路径失败: ../../../comm/helper/time_helper.js');
      try {
        globalTimeHelper = require('../config/project_helpers_config').timeHelper;
        globalTimeHelperPath = '../../../../comm/helper/time_helper.js';
        console.log('成功加载全局time_helper: ../../../../comm/helper/time_helper.js');
      } catch (e) {
        console.warn('尝试路径失败: ../../../../comm/helper/time_helper.js');
        console.error('所有time_helper路径加载失败，使用内部实现');
      }
    }
  }
}

// 尝试加载日期辅助类
let dateHelper = null;
try {
  dateHelper = require('../config/path_resolver').getProjectStorePath('helpers/date_helper.js');
  console.log('成功加载date_helper: ../../../../store/helpers/date_helper.js');
} catch (e) {
  console.warn('加载date_helper失败: ../../../../store/helpers/date_helper.js');
  try {
    dateHelper = require('../config/project_helpers_config').dateHelper;
    console.log('成功加载date_helper: ../../../../comm/helper/date_helper.js');
  } catch (e) {
    console.warn('加载date_helper失败: ../../../../comm/helper/date_helper.js');
    dateHelper = null;
  }
}

// 定义time_helper兼容层
const timeHelper = {
    // 获取时间戳
    time: function(fmt = '', timestamp = null) {
        try {
            // 优先使用全局timeHelper
            if (globalTimeHelper && typeof globalTimeHelper.time === 'function') {
                try {
                    return globalTimeHelper.time(fmt, timestamp);
                } catch (err) {
                    console.warn(`使用全局time_helper.time失败(${globalTimeHelperPath})，回退到本地实现`, err);
                    // 继续使用本地实现
                }
            }
            
            // 如果不需要格式化，直接返回时间戳
            if (!fmt) return Math.round(new Date().getTime() / 1000);
            
            // 日期格式化 - 使用Day.js
            try {
                // 确保时间戳正确处理
                const dayjsDate = timestamp 
                    ? dayjs(timestamp * 1000) // 秒级时间戳转毫秒
                    : dayjs();
                
                // 检查时间是否有效
                if (!dayjsDate.isValid()) {
                    console.warn('Day.js日期无效：', timestamp);
                    throw new Error('Invalid date');
                }
                
                return dayjsDate.format(fmt);
            } catch (err) {
                console.warn('使用Day.js格式化失败，回退到原始实现', err);
                
                // 日期格式化 - 原始实现
                const date = timestamp ? new Date(timestamp * 1000) : new Date();
                
                // 检查日期有效性
                if (isNaN(date.getTime())) {
                    console.error('无效的日期时间戳', timestamp);
                    return '';
                }
                
                // 年
                let Y = date.getFullYear();
                // 月，从0开始需要+1
                let M = date.getMonth() + 1;
                // 日
                let D = date.getDate();
                // 时
                let h = date.getHours();
                // 分
                let m = date.getMinutes();
                // 秒
                let s = date.getSeconds();
                
                // 补0操作
                if (M < 10) M = '0' + M;
                if (D < 10) D = '0' + D;
                if (h < 10) h = '0' + h;
                if (m < 10) m = '0' + m;
                if (s < 10) s = '0' + s;
                
                // 根据format格式进行替换
                return fmt
                  .replace('Y', Y)
                  .replace('M', M)
                  .replace('D', D)
                  .replace('h', h)
                  .replace('m', m)
                  .replace('s', s);
            }
        } catch (err) {
            console.error('time函数发生错误:', err);
            return timestamp ? timestamp.toString() : '';
        }
    },

    // 时间戳转时间
    timestamp2Time: function(timestamp, fmt = 'YYYY-MM-DD HH:mm:ss') {
        try {
            // 优先使用全局timeHelper
            if (globalTimeHelper && globalTimeHelper.timestamp2Time) {
                try {
                    return globalTimeHelper.timestamp2Time(timestamp, fmt);
                } catch (err) {
                    console.warn('全局timestamp2Time失败，使用本地实现', err);
                }
            }
            
            if (!timestamp) return '';
            
            // 使用Day.js实现
            try {
                const date = dayjs(timestamp * 1000); // 转为毫秒
                if (!date.isValid()) {
                    throw new Error('Invalid date from timestamp');
                }
                return date.format(fmt);
            } catch (e) {
                console.warn('Day.js转换时间戳失败，使用原始实现', e);
                
                // 原始实现
                const date = new Date(timestamp * 1000);
                if (isNaN(date.getTime())) {
                    return '';
                }
                
                const year = date.getFullYear();
                const month = (date.getMonth() + 1).toString().padStart(2, '0');
                const day = date.getDate().toString().padStart(2, '0');
                const hours = date.getHours().toString().padStart(2, '0');
                const minutes = date.getMinutes().toString().padStart(2, '0');
                const seconds = date.getSeconds().toString().padStart(2, '0');
                
                return fmt
                  .replace('YYYY', year)
                  .replace('MM', month)
                  .replace('DD', day)
                  .replace('HH', hours)
                  .replace('mm', minutes)
                  .replace('ss', seconds);
            }
        } catch (err) {
            console.error('timestamp2Time函数发生错误:', err);
            return '';
        }
    },

    // 时间戳转日期
    timestamp2Date: function(timestamp, fmt = 'YYYY-MM-DD') {
        return this.timestamp2Time(timestamp, fmt);
    },

    // 时间转时间戳
    time2Timestamp: function(date) {
        if (!date) return 0;
        try {
            const timestamp = Math.floor(new Date(date).getTime() / 1000);
            if (isNaN(timestamp)) {
                throw new Error('无效的日期字符串');
            }
            return timestamp;
        } catch (err) {
            console.error('time2Timestamp函数发生错误:', err);
            return 0;
        }
    },

    // 获取星期几
    week: function(date) {
        try {
            if (!date) return '';
            const weekdays = ['日', '一', '二', '三', '四', '五', '六'];
            const d = date ? new Date(date) : new Date();
            
            if (isNaN(d.getTime())) {
                throw new Error('无效的日期');
            }
            
            return '星期' + weekdays[d.getDay()];
        } catch (err) {
            console.error('week函数发生错误:', err);
            return '';
        }
    },

    // 获取月份第一天时间戳
    getMonthFirstTimestamp: function(timestamp = null) {
        try {
            // 使用Day.js实现
            const date = timestamp ? dayjs(timestamp * 1000) : dayjs();
            return date.startOf('month').unix();
        } catch (err) {
            console.warn('Day.js获取月初失败，使用原始实现', err);
            
            // 原始实现
            const date = timestamp ? new Date(timestamp * 1000) : new Date();
            const firstDay = new Date(date.getFullYear(), date.getMonth(), 1);
            return Math.floor(firstDay.getTime() / 1000);
        }
    },

    // 获取月份最后一天时间戳
    getMonthLastTimestamp: function(timestamp = null) {
        try {
            // 使用Day.js实现
            const date = timestamp ? dayjs(timestamp * 1000) : dayjs();
            return date.endOf('month').unix();
        } catch (err) {
            console.warn('Day.js获取月末失败，使用原始实现', err);
            
            // 原始实现
            const date = timestamp ? new Date(timestamp * 1000) : new Date();
            const lastDay = new Date(date.getFullYear(), date.getMonth() + 1, 0);
            return Math.floor(lastDay.getTime() / 1000);
        }
    },
    
    // 获取周开始时间戳（周一为开始）
    getWeekFirstTimestamp: function(timestamp = null) {
        try {
            // 使用Day.js实现
            const date = timestamp ? dayjs(timestamp * 1000) : dayjs();
            // 按周一为一周的开始计算
            return date.startOf('week').add(1, 'day').unix();
        } catch (err) {
            console.warn('Day.js获取周开始失败，使用原始实现', err);
            
            // 原始实现
            const date = timestamp ? new Date(timestamp * 1000) : new Date();
            const day = date.getDay() || 7; // 如果是周日则转为7
            const diff = date.getDate() - day + 1; // 周一日期
            const monday = new Date(date.setDate(diff));
            monday.setHours(0, 0, 0, 0);
            return Math.floor(monday.getTime() / 1000);
        }
    },
    
    // 获取周结束时间戳（周日为结束）
    getWeekLastTimestamp: function(timestamp = null) {
        try {
            // 使用Day.js实现
            const date = timestamp ? dayjs(timestamp * 1000) : dayjs();
            return date.endOf('week').unix();
        } catch (err) {
            console.warn('Day.js获取周结束失败，使用原始实现', err);
            
            // 原始实现
            const date = timestamp ? new Date(timestamp * 1000) : new Date();
            const day = date.getDay() || 7; // 如果是周日则转为7
            const diff = date.getDate() - day + 7; // 周日日期
            const sunday = new Date(date.setDate(diff));
            sunday.setHours(23, 59, 59, 999);
            return Math.floor(sunday.getTime() / 1000);
        }
    },

    // 获取今天开始的最小时间戳
    getNowMinTimestamp: function() {
        return this.getWeekFirstTimestamp();
    },

    // 简单格式化日期
    simpleDate: function(timestamp = null) {
        try {
            return this.timestamp2Date(timestamp, 'YYYY.MM.DD');
        } catch (err) {
            console.error('simpleDate函数发生错误:', err);
            
            // 原始实现
            const date = timestamp ? new Date(timestamp * 1000) : new Date();
            const year = date.getFullYear();
            const month = (date.getMonth() + 1).toString().padStart(2, '0');
            const day = date.getDate().toString().padStart(2, '0');
            return `${year}.${month}.${day}`;
        }
    },

    // 中文格式化日期
    fmtDateCHN: function(timestamp = null) {
        try {
            // 使用时间戳转换实现
            const date = timestamp ? dayjs(timestamp * 1000) : dayjs();
            return `${date.year()}年${date.month() + 1}月${date.date()}日`;
        } catch (err) {
            console.warn('Day.js中文格式化失败，使用原始实现', err);
            
            // 原始实现
            const date = timestamp ? new Date(timestamp * 1000) : new Date();
            const year = date.getFullYear();
            const month = date.getMonth() + 1;
            const day = date.getDate();
            return `${year}年${month}月${day}日`;
        }
    },

    // 中文格式化日期（别名）
    fmtDateCN: function(timestamp = null) {
        return this.fmtDateCHN(timestamp);
    },

    // 中文格式化日期时间
    fmtDateTimeCN: function(timestamp = null) {
        try {
            // 使用Day.js格式化实现
            const date = timestamp ? dayjs(timestamp * 1000) : dayjs();
            return `${date.year()}年${date.month() + 1}月${date.date()}日 ${date.format('HH:mm:ss')}`;
        } catch (err) {
            console.warn('Day.js中文时间格式化失败，使用原始实现', err);
            
            // 原始实现
            const date = timestamp ? new Date(timestamp * 1000) : new Date();
            const year = date.getFullYear();
            const month = date.getMonth() + 1;
            const day = date.getDate();
            const hours = date.getHours().toString().padStart(2, '0');
            const minutes = date.getMinutes().toString().padStart(2, '0');
            const seconds = date.getSeconds().toString().padStart(2, '0');
            return `${year}年${month}月${day}日 ${hours}:${minutes}:${seconds}`;
        }
    }
};

// 导出兼容层
module.exports = timeHelper;

